/*******************************************************************************
* Copyright (c) 2005, 2016 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
* Tom Hochstein (Freescale) - Bug 393703 - NotHandledException selecting inactive command under 'Previous Choices' in Quick access
* René Brandstetter - Bug 433778
* Patrik Suzzi <psuzzi@gmail.com> - Bug 491410
*******************************************************************************/
package org.eclipse.ui.internal.quickaccess;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import org.eclipse.core.commands.Command;
import org.eclipse.core.runtime.Adapters;
import org.eclipse.core.runtime.Assert;
import org.eclipse.e4.core.commands.ExpressionContext;
import org.eclipse.e4.ui.model.application.MApplication;
import org.eclipse.e4.ui.model.application.ui.basic.MWindow;
import org.eclipse.jface.bindings.TriggerSequence;
import org.eclipse.jface.bindings.keys.KeySequence;
import org.eclipse.jface.bindings.keys.SWTKeySupport;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.dialogs.PopupDialog;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.layout.GridLayoutFactory;
import org.eclipse.jface.util.Util;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.graphics.FontMetrics;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.internal.WorkbenchPlugin;
import org.eclipse.ui.internal.WorkbenchWindow;
import org.eclipse.ui.internal.progress.ProgressManagerUtil;
import org.eclipse.ui.keys.IBindingService;
/**
* This is the quick access popup dialog used in 3.x. The new quick access is
* done through a shell in {@link SearchField}.
*
* @since 3.3
*
*/
public class QuickAccessDialog extends PopupDialog {
private TriggerSequence[] invokingCommandKeySequences;
private Command invokingCommand;
private QuickAccessContents contents;
private KeyAdapter keyAdapter;
private Text filterText;
private IWorkbenchWindow window;
private LinkedList previousPicksList = new LinkedList();
private static final String TEXT_ARRAY = "textArray"; //$NON-NLS-1$
private static final String TEXT_ENTRIES = "textEntries"; //$NON-NLS-1$
private static final String ORDERED_PROVIDERS = "orderedProviders"; //$NON-NLS-1$
private static final String ORDERED_ELEMENTS = "orderedElements"; //$NON-NLS-1$
static final int MAXIMUM_NUMBER_OF_ELEMENTS = 60;
static final int MAXIMUM_NUMBER_OF_TEXT_ENTRIES_PER_ELEMENT = 3;
protected Map textMap = new HashMap();
protected Map elementMap = new HashMap();
protected Map providerMap;
public QuickAccessDialog(final IWorkbenchWindow window, final Command invokingCommand) {
super(ProgressManagerUtil.getDefaultParent(), SWT.RESIZE, true, true, // persist
// size
false, // but not location
true, true, null, QuickAccessMessages.QuickAccess_StartTypingToFindMatches);
this.window = window;
WorkbenchWindow workbenchWindow = (WorkbenchWindow) window;
final MWindow model = workbenchWindow.getModel();
BusyIndicator.showWhile(window.getShell() == null ? null : window.getShell().getDisplay(),
() -> {
final CommandProvider commandProvider = new CommandProvider();
commandProvider.setSnapshot(new ExpressionContext(model.getContext()
.getActiveLeaf()));
QuickAccessProvider[] providers = new QuickAccessProvider[] {
new PreviousPicksProvider(previousPicksList),
new EditorProvider(),
new ViewProvider(model.getContext().get(MApplication.class), model),
new PerspectiveProvider(), commandProvider, new ActionProvider(),
new WizardProvider(), new PreferenceProvider(),
new PropertiesProvider() };
providerMap = new HashMap();
for (QuickAccessProvider provider : providers) {
providerMap.put(provider.getId(), provider);
}
QuickAccessDialog.this.contents = new QuickAccessContents(providers) {
@Override
protected void updateFeedback(boolean filterTextEmpty,
boolean showAllMatches) {
if (filterTextEmpty) {
setInfoText(QuickAccessMessages.QuickAccess_StartTypingToFindMatches);
} else {
TriggerSequence[] sequences = getInvokingCommandKeySequences();
if (showAllMatches || sequences == null
|| sequences.length == 0) {
setInfoText(""); //$NON-NLS-1$
} else {
setInfoText(NLS
.bind(QuickAccessMessages.QuickAccess_PressKeyToShowAllMatches,
sequences[0].format()));
}
}
}
@Override
protected void doClose() {
QuickAccessDialog.this.close();
}
/**
* @param element
*/
void addPreviousPick(String text, Object element) {
// previousPicksList:
// Remove element from previousPicksList so
// there are no duplicates
// If list is max size, remove last(oldest)
// element
// Remove entries for removed element from
// elementMap and textMap
// Add element to front of previousPicksList
previousPicksList.remove(element);
if (previousPicksList.size() == MAXIMUM_NUMBER_OF_ELEMENTS) {
Object removedElement = previousPicksList.removeLast();
ArrayList removedList = (ArrayList) textMap
.remove(removedElement);
for (int i = 0; i < removedList.size(); i++) {
elementMap.remove(removedList.get(i));
}
}
previousPicksList.addFirst(element);
// textMap:
// Get list of strings for element from textMap
// Create new list for element if there isn't
// one and put
// element->textList in textMap
// Remove rememberedText from list
// If list is max size, remove first(oldest)
// string
// Remove text from elementMap
// Add rememberedText to list of strings for
// element in textMap
ArrayList textList = (ArrayList) textMap.get(element);
if (textList == null) {
textList = new ArrayList();
textMap.put(element, textList);
}
textList.remove(text);
if (textList.size() == MAXIMUM_NUMBER_OF_TEXT_ENTRIES_PER_ELEMENT) {
Object removedText = textList.remove(0);
elementMap.remove(removedText);
}
if (text.length() > 0) {
textList.add(text);
// elementMap:
// Put rememberedText->element in elementMap
// If it replaced a different element update
// textMap and
// PreviousPicksList
Object replacedElement = elementMap.put(text, element);
if (replacedElement != null && !replacedElement.equals(element)) {
textList = (ArrayList) textMap.get(replacedElement);
if (textList != null) {
textList.remove(text);
if (textList.isEmpty()) {
textMap.remove(replacedElement);
previousPicksList.remove(replacedElement);
}
}
}
}
}
@Override
protected QuickAccessElement getPerfectMatch(String filter) {
QuickAccessElement perfectMatch = (QuickAccessElement) elementMap
.get(filter);
return perfectMatch;
}
@Override
protected void handleElementSelected(String text, Object selectedElement) {
if (selectedElement instanceof QuickAccessElement) {
addPreviousPick(text, selectedElement);
storeDialog(getDialogSettings());
/*
* Execute after the dialog has been fully
* closed/disposed and the correct
* EclipseContext is in place.
*/
final QuickAccessElement element = (QuickAccessElement) selectedElement;
window.getShell().getDisplay().asyncExec(() -> element.execute());
}
}
};
restoreDialog();
QuickAccessDialog.this.invokingCommand = invokingCommand;
if (QuickAccessDialog.this.invokingCommand != null
&& !QuickAccessDialog.this.invokingCommand.isDefined()) {
QuickAccessDialog.this.invokingCommand = null;
} else {
// Pre-fetch key sequence - do not change because
// scope will
// change later.
getInvokingCommandKeySequences();
}
// create early
create();
});
QuickAccessDialog.this.contents.refresh(""); //$NON-NLS-1$
}
@Override
protected Control createTitleControl(Composite parent) {
filterText = new Text(parent, SWT.NONE);
GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER).grab(true, false)
.applyTo(filterText);
contents.hookFilterText(filterText);
filterText.addKeyListener(getKeyAdapter());
return filterText;
}
@Override
protected Control createDialogArea(Composite parent) {
Composite composite = (Composite) super.createDialogArea(parent);
boolean isWin32 = Util.isWindows();
GridLayoutFactory.fillDefaults().extendedMargins(isWin32 ? 0 : 3, 3, 2, 2)
.applyTo(composite);
Table table = contents.createTable(composite, getDefaultOrientation());
table.addKeyListener(getKeyAdapter());
return composite;
}
final protected TriggerSequence[] getInvokingCommandKeySequences() {
if (invokingCommandKeySequences == null) {
if (invokingCommand != null) {
IBindingService bindingService =
Adapters.adapt(window.getWorkbench(), IBindingService.class);
invokingCommandKeySequences = bindingService.getActiveBindingsFor(invokingCommand.getId());
}
}
return invokingCommandKeySequences;
}
private KeyAdapter getKeyAdapter() {
if (keyAdapter == null) {
keyAdapter = new KeyAdapter() {
@Override
public void keyPressed(KeyEvent e) {
int accelerator = SWTKeySupport.convertEventToUnmodifiedAccelerator(e);
KeySequence keySequence = KeySequence.getInstance(SWTKeySupport
.convertAcceleratorToKeyStroke(accelerator));
TriggerSequence[] sequences = getInvokingCommandKeySequences();
if (sequences == null)
return;
for (TriggerSequence sequence : sequences) {
if (sequence.equals(keySequence)) {
e.doit = false;
contents.setShowAllMatches(!contents.getShowAllMatches());
return;
}
}
}
};
}
return keyAdapter;
}
@Override
protected Control getFocusControl() {
return filterText;
}
@Override
public boolean close() {
storeDialog(getDialogSettings());
return super.close();
}
@Override
protected Point getDefaultSize() {
GC gc = new GC(getContents());
FontMetrics fontMetrics = gc.getFontMetrics();
gc.dispose();
int x = Dialog.convertHorizontalDLUsToPixels(fontMetrics, 300);
if (x < 350) {
x = 350;
}
int y = Dialog.convertVerticalDLUsToPixels(fontMetrics, 270);
if (y < 420) {
y = 420;
}
return new Point(x, y);
}
@Override
protected Point getDefaultLocation(Point initialSize) {
Point size = new Point(400, 400);
Rectangle parentBounds = getParentShell().getBounds();
int x = parentBounds.x + parentBounds.width / 2 - size.x / 2;
int y = parentBounds.y + parentBounds.height / 2 - size.y / 2;
return new Point(x, y);
}
@Override
protected IDialogSettings getDialogSettings() {
final IDialogSettings workbenchDialogSettings = WorkbenchPlugin.getDefault()
.getDialogSettings();
IDialogSettings result = workbenchDialogSettings.getSection(getId());
if (result == null) {
result = workbenchDialogSettings.addNewSection(getId());
}
return result;
}
protected String getId() {
return "org.eclipse.ui.internal.QuickAccess"; //$NON-NLS-1$
}
private void storeDialog(IDialogSettings dialogSettings) {
String[] orderedElements = new String[previousPicksList.size()];
String[] orderedProviders = new String[previousPicksList.size()];
String[] textEntries = new String[previousPicksList.size()];
ArrayList arrayList = new ArrayList();
for (int i = 0; i < orderedElements.length; i++) {
QuickAccessElement quickAccessElement = (QuickAccessElement) previousPicksList.get(i);
ArrayList elementText = (ArrayList) textMap.get(quickAccessElement);
Assert.isNotNull(elementText);
orderedElements[i] = quickAccessElement.getId();
orderedProviders[i] = quickAccessElement.getProvider().getId();
arrayList.addAll(elementText);
textEntries[i] = elementText.size() + ""; //$NON-NLS-1$
}
String[] textArray = (String[]) arrayList.toArray(new String[arrayList.size()]);
dialogSettings.put(ORDERED_ELEMENTS, orderedElements);
dialogSettings.put(ORDERED_PROVIDERS, orderedProviders);
dialogSettings.put(TEXT_ENTRIES, textEntries);
dialogSettings.put(TEXT_ARRAY, textArray);
}
private void restoreDialog() {
IDialogSettings dialogSettings = getDialogSettings();
if (dialogSettings != null) {
String[] orderedElements = dialogSettings.getArray(ORDERED_ELEMENTS);
String[] orderedProviders = dialogSettings.getArray(ORDERED_PROVIDERS);
String[] textEntries = dialogSettings.getArray(TEXT_ENTRIES);
String[] textArray = dialogSettings.getArray(TEXT_ARRAY);
elementMap = new HashMap();
textMap = new HashMap();
previousPicksList = new LinkedList();
if (orderedElements != null && orderedProviders != null && textEntries != null
&& textArray != null) {
int arrayIndex = 0;
for (int i = 0; i < orderedElements.length; i++) {
QuickAccessProvider quickAccessProvider = (QuickAccessProvider) providerMap
.get(orderedProviders[i]);
int numTexts = Integer.parseInt(textEntries[i]);
if (quickAccessProvider != null) {
QuickAccessElement quickAccessElement = quickAccessProvider
.getElementForId(orderedElements[i]);
if (quickAccessElement != null) {
ArrayList arrayList = new ArrayList();
for (int j = arrayIndex; j < arrayIndex + numTexts; j++) {
String text = textArray[j];
// text length can be zero for old workspaces,
// see bug 190006
if (text.length() > 0) {
arrayList.add(text);
elementMap.put(text, quickAccessElement);
}
}
textMap.put(quickAccessElement, arrayList);
previousPicksList.add(quickAccessElement);
}
}
arrayIndex += numTexts;
}
}
}
}
}